def restore_ip_addresses(s):
    """
    使用回溯算法复原IP地址
    
    Args:
        s (str): 只包含数字的字符串
        
    Returns:
        List[str]: 所有可能的有效IP地址列表
    """
    def is_valid_segment(segment):
        """
        判断IP段是否有效
        
        Args:
            segment (str): IP段字符串
            
        Returns:
            bool: 是否有效
        """
        # 空字符串无效
        if not segment:
            return False
        
        # 长度超过3无效
        if len(segment) > 3:
            return False
        
        # 有前导0且长度大于1无效（除了"0"本身）
        if len(segment) > 1 and segment[0] == '0':
            return False
        
        # 数值超过255无效
        num = int(segment)
        if num > 255:
            return False
        
        return True
    
    def backtrack(start_idx, path, result):
        """
        回溯算法核心函数
        
        Args:
            start_idx (int): 当前处理的字符索引
            path (List[str]): 当前已构建的IP段路径
            result (List[str]): 存储所有有效IP地址的结果列表
        """
        # 如果已经有4个段了
        if len(path) == 4:
            # 如果正好用完所有字符，说明找到一个有效IP
            if start_idx == len(s):
                result.append('.'.join(path))
            return
        
        # 剩余字符数量
        remaining = len(s) - start_idx
        # 剩余需要的段数
        segments_needed = 4 - len(path)
        
        # 剪枝：如果剩余字符太少或太多，直接返回
        if remaining < segments_needed or remaining > segments_needed * 3:
            return
        
        # 尝试1到3位数的段
        for length in range(1, 4):
            # 确保不越界
            if start_idx + length > len(s):
                break
            
            # 提取当前段
            segment = s[start_idx:start_idx + length]
            
            # 检查段是否有效
            if is_valid_segment(segment):
                # 选择：添加当前段到路径
                path.append(segment)
                # 递归：处理下一个位置
                backtrack(start_idx + length, path, result)
                # 撤销：回溯，移除当前段
                path.pop()
    
    # 边界情况检查
    if not s or len(s) < 4 or len(s) > 12:
        return []
    
    result = []
    backtrack(0, [], result)
    return result

def restore_ip_addresses_optimized(s):
    """
    优化版本的IP地址复原算法
    使用更多剪枝策略提高效率
    """
    def is_valid_segment(segment):
        if not segment or len(segment) > 3:
            return False
        if len(segment) > 1 and segment[0] == '0':
            return False
        return int(segment) <= 255
    
    def backtrack(start, path, result):
        # 如果已经有4个段
        if len(path) == 4:
            if start == len(s):
                result.append('.'.join(path))
            return
        
        # 更严格的剪枝
        remaining_chars = len(s) - start
        remaining_segments = 4 - len(path)
        
        # 每个段至少1个字符，最多3个字符
        if remaining_chars < remaining_segments or remaining_chars > remaining_segments * 3:
            return
        
        # 尝试不同长度的段
        for length in range(1, min(4, remaining_chars - remaining_segments + 2)):
            if start + length > len(s):
                break
                
            segment = s[start:start + length]
            
            if is_valid_segment(segment):
                path.append(segment)
                backtrack(start + length, path, result)
                path.pop()
    
    if not s or len(s) < 4 or len(s) > 12:
        return []
    
    result = []
    backtrack(0, [], result)
    return result

# 为了兼容性，提供一个主函数
def solve_ip_restoration(s):
    """主求解函数"""
    return restore_ip_addresses_optimized(s)
